// $ANTLR 3.1.1 LPMEDSemAnalyzer.g 2009-10-05 23:27:45
// The variable 'variable' is assigned but its value is never used.
#pragma warning disable 168, 219
// Unreachable code detected.
#pragma warning disable 162
namespace  Core.ANTLRGrammars 
{

using Descriptions_DomainModel.Model;
using CommonClasses.ANTLRGrammars;
using System.Collections.Generic;


using System;
using Antlr.Runtime;
using Antlr.Runtime.Tree;using IList 		= System.Collections.IList;
using ArrayList 	= System.Collections.ArrayList;
using Stack 		= Antlr.Runtime.Collections.StackList;

using IDictionary	= System.Collections.IDictionary;
using Hashtable 	= System.Collections.Hashtable;

public partial class LPMEDSemAnalyzer : TreeParser
{
    public static readonly string[] tokenNames = new string[] 
	{
        "<invalid>", 
		"<EOR>", 
		"<DOWN>", 
		"<UP>", 
		"CPROGRAM", 
		"CDEVICE", 
		"CTYPE", 
		"CBLOCK", 
		"CSTATEMENT", 
		"CIFTE", 
		"CASSIGN", 
		"CWHILE", 
		"CFOR", 
		"CFORDEC", 
		"CUNARMIN", 
		"CMETHODNAME", 
		"CCALL", 
		"CINT", 
		"CFLOAT", 
		"CBOOL", 
		"CSYNCCALL", 
		"CASYNCCALL", 
		"CWAITTHECALL", 
		"CWAITANYCALL", 
		"CENDTHECALL", 
		"OBJECTNAME", 
		"MEMBERNAME", 
		"NODES", 
		"CGETSTATE", 
		"CBREAKPOINT", 
		"CREGMETHACCESS", 
		"CREGFUNCACCESS", 
		"CTERMINATEALL", 
		"CASYNCFUNCCALL", 
		"CSYNCFUNCCALL", 
		"CWAITFUNCFINISH", 
		"CDEFUN", 
		"PARAMS", 
		"PARAM", 
		"TERMINATEALL", 
		"OpIncDec", 
		"OpNegation", 
		"OpUnar", 
		"OpDivMul", 
		"OpAddSub", 
		"OpLogicalA", 
		"OpLogicalB", 
		"OpAnd", 
		"OpOr", 
		"TYPE", 
		"DBOOL", 
		"DEVICE", 
		"STATE", 
		"ENDDEVICE", 
		"INT", 
		"FLOAT", 
		"IF", 
		"THEN", 
		"ELSE", 
		"FOR", 
		"WHILE", 
		"WAIT", 
		"GO", 
		"ENDPRESSURE", 
		"VAR", 
		"BREAKPOINT", 
		"DEFUN", 
		"WS", 
		"NEWLINE", 
		"LINECOMMENT", 
		"ID", 
		"OBRACKET", 
		"CBRACKET", 
		"CURLYOBRACKET", 
		"CURLYCBRACKET", 
		"EQUALS", 
		"DOT", 
		"SEMI", 
		"COLON", 
		"COMMA", 
		"'('", 
		"')'"
    };

    public const int OpIncDec = 40;
    public const int WHILE = 60;
    public const int OpLogicalA = 45;
    public const int OBJECTNAME = 25;
    public const int OpAnd = 47;
    public const int CPROGRAM = 4;
    public const int OpLogicalB = 46;
    public const int OpNegation = 41;
    public const int CTYPE = 6;
    public const int DBOOL = 50;
    public const int FOR = 59;
    public const int PARAM = 38;
    public const int FLOAT = 55;
    public const int EQUALS = 75;
    public const int OpAddSub = 44;
    public const int CURLYCBRACKET = 74;
    public const int LINECOMMENT = 69;
    public const int ID = 70;
    public const int EOF = -1;
    public const int CASYNCCALL = 21;
    public const int CSYNCFUNCCALL = 34;
    public const int IF = 56;
    public const int TYPE = 49;
    public const int CIFTE = 9;
    public const int CWAITANYCALL = 23;
    public const int CWAITFUNCFINISH = 35;
    public const int THEN = 57;
    public const int CFORDEC = 13;
    public const int COMMA = 79;
    public const int OpDivMul = 43;
    public const int CDEVICE = 5;
    public const int CURLYOBRACKET = 73;
    public const int CSYNCCALL = 20;
    public const int CFOR = 12;
    public const int DEVICE = 51;
    public const int NODES = 27;
    public const int VAR = 64;
    public const int CREGFUNCACCESS = 31;
    public const int ENDDEVICE = 53;
    public const int DOT = 76;
    public const int CMETHODNAME = 15;
    public const int CBRACKET = 72;
    public const int PARAMS = 37;
    public const int MEMBERNAME = 26;
    public const int CWHILE = 11;
    public const int STATE = 52;
    public const int T__80 = 80;
    public const int T__81 = 81;
    public const int DEFUN = 66;
    public const int OpUnar = 42;
    public const int CTERMINATEALL = 32;
    public const int CREGMETHACCESS = 30;
    public const int ELSE = 58;
    public const int CDEFUN = 36;
    public const int CSTATEMENT = 8;
    public const int CUNARMIN = 14;
    public const int INT = 54;
    public const int WAIT = 61;
    public const int SEMI = 77;
    public const int CASSIGN = 10;
    public const int COLON = 78;
    public const int CBREAKPOINT = 29;
    public const int CINT = 17;
    public const int WS = 67;
    public const int TERMINATEALL = 39;
    public const int CENDTHECALL = 24;
    public const int NEWLINE = 68;
    public const int OpOr = 48;
    public const int ENDPRESSURE = 63;
    public const int CBLOCK = 7;
    public const int CCALL = 16;
    public const int CASYNCFUNCCALL = 33;
    public const int CGETSTATE = 28;
    public const int GO = 62;
    public const int OBRACKET = 71;
    public const int CBOOL = 19;
    public const int CFLOAT = 18;
    public const int BREAKPOINT = 65;
    public const int CWAITTHECALL = 22;

    // delegates
    // delegators



        public LPMEDSemAnalyzer(ITreeNodeStream input)
    		: this(input, new RecognizerSharedState()) {
        }

        public LPMEDSemAnalyzer(ITreeNodeStream input, RecognizerSharedState state)
    		: base(input, state) {
            InitializeCyclicDFAs();

             
        }
        

    override public string[] TokenNames {
		get { return LPMEDSemAnalyzer.tokenNames; }
    }

    override public string GrammarFileName {
		get { return "LPMEDSemAnalyzer.g"; }
    }


    public Checker check;


    protected class program_scope 
    {
        protected internal string DDname;
    }
    protected Stack program_stack = new Stack();


    // $ANTLR start "program"
    // LPMEDSemAnalyzer.g:23:1: program : ^( CPROGRAM ^( CDEVICE name= ID ) block ) ;
    public void program() // throws RecognitionException [1]
    {   
        program_stack.Push(new program_scope());
        CommonTree name = null;

        try 
    	{
            // LPMEDSemAnalyzer.g:28:3: ( ^( CPROGRAM ^( CDEVICE name= ID ) block ) )
            // LPMEDSemAnalyzer.g:29:5: ^( CPROGRAM ^( CDEVICE name= ID ) block )
            {
            	Match(input,CPROGRAM,FOLLOW_CPROGRAM_in_program67); if (state.failed) return ;

            	Match(input, Token.DOWN, null); if (state.failed) return ;
            	Match(input,CDEVICE,FOLLOW_CDEVICE_in_program70); if (state.failed) return ;

            	Match(input, Token.DOWN, null); if (state.failed) return ;
            	name=(CommonTree)Match(input,ID,FOLLOW_ID_in_program74); if (state.failed) return ;

            	Match(input, Token.UP, null); if (state.failed) return ;
            	if ( state.backtracking == 0 ) 
            	{
            	  ((program_scope)program_stack.Peek()).DDname = ((name != null) ? name.Text : null);
            	}
            	PushFollow(FOLLOW_block_in_program79);
            	block();
            	state.followingStackPointer--;
            	if (state.failed) return ;

            	Match(input, Token.UP, null); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            program_stack.Pop();
        }
        return ;
    }
    // $ANTLR end "program"


    // $ANTLR start "block"
    // LPMEDSemAnalyzer.g:32:1: block : ( varDecList )* blockStmt ;
    public void block() // throws RecognitionException [1]
    {   
        try 
    	{
            // LPMEDSemAnalyzer.g:32:7: ( ( varDecList )* blockStmt )
            // LPMEDSemAnalyzer.g:32:9: ( varDecList )* blockStmt
            {
            	// LPMEDSemAnalyzer.g:32:9: ( varDecList )*
            	do 
            	{
            	    int alt1 = 2;
            	    int LA1_0 = input.LA(1);

            	    if ( (LA1_0 == CTYPE) )
            	    {
            	        alt1 = 1;
            	    }


            	    switch (alt1) 
            		{
            			case 1 :
            			    // LPMEDSemAnalyzer.g:32:10: varDecList
            			    {
            			    	PushFollow(FOLLOW_varDecList_in_block92);
            			    	varDecList();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return ;

            			    }
            			    break;

            			default:
            			    goto loop1;
            	    }
            	} while (true);

            	loop1:
            		;	// Stops C# compiler whining that label 'loop1' has no statements

            	PushFollow(FOLLOW_blockStmt_in_block96);
            	blockStmt();
            	state.followingStackPointer--;
            	if (state.failed) return ;

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "block"


    // $ANTLR start "varDecList"
    // LPMEDSemAnalyzer.g:36:1: varDecList : ( varDecListAtom )+ ;
    public void varDecList() // throws RecognitionException [1]
    {   
        try 
    	{
            // LPMEDSemAnalyzer.g:36:12: ( ( varDecListAtom )+ )
            // LPMEDSemAnalyzer.g:36:14: ( varDecListAtom )+
            {
            	// LPMEDSemAnalyzer.g:36:14: ( varDecListAtom )+
            	int cnt2 = 0;
            	do 
            	{
            	    int alt2 = 2;
            	    int LA2_0 = input.LA(1);

            	    if ( (LA2_0 == CTYPE) )
            	    {
            	        alt2 = 1;
            	    }


            	    switch (alt2) 
            		{
            			case 1 :
            			    // LPMEDSemAnalyzer.g:36:14: varDecListAtom
            			    {
            			    	PushFollow(FOLLOW_varDecListAtom_in_varDecList106);
            			    	varDecListAtom();
            			    	state.followingStackPointer--;
            			    	if (state.failed) return ;

            			    }
            			    break;

            			default:
            			    if ( cnt2 >= 1 ) goto loop2;
            			    if ( state.backtracking > 0 ) {state.failed = true; return ;}
            		            EarlyExitException eee =
            		                new EarlyExitException(2, input);
            		            throw eee;
            	    }
            	    cnt2++;
            	} while (true);

            	loop2:
            		;	// Stops C# compiler whinging that label 'loop2' has no statements


            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "varDecList"


    // $ANTLR start "varDecListAtom"
    // LPMEDSemAnalyzer.g:38:1: varDecListAtom : ^( CTYPE TYPE peremDecList ) ;
    public void varDecListAtom() // throws RecognitionException [1]
    {   
        CommonTree TYPE1 = null;

        try 
    	{
            // LPMEDSemAnalyzer.g:38:16: ( ^( CTYPE TYPE peremDecList ) )
            // LPMEDSemAnalyzer.g:38:19: ^( CTYPE TYPE peremDecList )
            {
            	Match(input,CTYPE,FOLLOW_CTYPE_in_varDecListAtom118); if (state.failed) return ;

            	Match(input, Token.DOWN, null); if (state.failed) return ;
            	TYPE1=(CommonTree)Match(input,TYPE,FOLLOW_TYPE_in_varDecListAtom120); if (state.failed) return ;
            	if ( state.backtracking == 0 ) 
            	{
            	  check.ActiveName = ((TYPE1 != null) ? TYPE1.Text : null);
            	}
            	PushFollow(FOLLOW_peremDecList_in_varDecListAtom124);
            	peremDecList();
            	state.followingStackPointer--;
            	if (state.failed) return ;

            	Match(input, Token.UP, null); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "varDecListAtom"


    // $ANTLR start "peremDecList"
    // LPMEDSemAnalyzer.g:40:1: peremDecList : (s+= ID )+ ;
    public void peremDecList() // throws RecognitionException [1]
    {   
        CommonTree s = null;
        IList list_s = null;

        try 
    	{
            // LPMEDSemAnalyzer.g:40:14: ( (s+= ID )+ )
            // LPMEDSemAnalyzer.g:40:16: (s+= ID )+
            {
            	// LPMEDSemAnalyzer.g:40:17: (s+= ID )+
            	int cnt3 = 0;
            	do 
            	{
            	    int alt3 = 2;
            	    int LA3_0 = input.LA(1);

            	    if ( (LA3_0 == ID) )
            	    {
            	        alt3 = 1;
            	    }


            	    switch (alt3) 
            		{
            			case 1 :
            			    // LPMEDSemAnalyzer.g:40:17: s+= ID
            			    {
            			    	s=(CommonTree)Match(input,ID,FOLLOW_ID_in_peremDecList136); if (state.failed) return ;
            			    	if (list_s == null) list_s = new ArrayList();
            			    	list_s.Add(s);


            			    }
            			    break;

            			default:
            			    if ( cnt3 >= 1 ) goto loop3;
            			    if ( state.backtracking > 0 ) {state.failed = true; return ;}
            		            EarlyExitException eee =
            		                new EarlyExitException(3, input);
            		            throw eee;
            	    }
            	    cnt3++;
            	} while (true);

            	loop3:
            		;	// Stops C# compiler whinging that label 'loop3' has no statements

            	if ( state.backtracking == 0 ) 
            	{
            	  check.AddNewVarList(list_s);
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "peremDecList"


    // $ANTLR start "blockStmt"
    // LPMEDSemAnalyzer.g:44:1: blockStmt : ^( CSTATEMENT ( stmt )* ) ;
    public void blockStmt() // throws RecognitionException [1]
    {   
        try 
    	{
            // LPMEDSemAnalyzer.g:44:11: ( ^( CSTATEMENT ( stmt )* ) )
            // LPMEDSemAnalyzer.g:44:13: ^( CSTATEMENT ( stmt )* )
            {
            	Match(input,CSTATEMENT,FOLLOW_CSTATEMENT_in_blockStmt150); if (state.failed) return ;

            	if ( input.LA(1) == Token.DOWN )
            	{
            	    Match(input, Token.DOWN, null); if (state.failed) return ;
            	    // LPMEDSemAnalyzer.g:44:26: ( stmt )*
            	    do 
            	    {
            	        int alt4 = 2;
            	        int LA4_0 = input.LA(1);

            	        if ( ((LA4_0 >= CSTATEMENT && LA4_0 <= CFOR) || LA4_0 == CCALL || (LA4_0 >= CBREAKPOINT && LA4_0 <= CREGMETHACCESS) || (LA4_0 >= CTERMINATEALL && LA4_0 <= CWAITFUNCFINISH)) )
            	        {
            	            alt4 = 1;
            	        }


            	        switch (alt4) 
            	    	{
            	    		case 1 :
            	    		    // LPMEDSemAnalyzer.g:44:26: stmt
            	    		    {
            	    		    	PushFollow(FOLLOW_stmt_in_blockStmt152);
            	    		    	stmt();
            	    		    	state.followingStackPointer--;
            	    		    	if (state.failed) return ;

            	    		    }
            	    		    break;

            	    		default:
            	    		    goto loop4;
            	        }
            	    } while (true);

            	    loop4:
            	    	;	// Stops C# compiler whining that label 'loop4' has no statements


            	    Match(input, Token.UP, null); if (state.failed) return ;
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "blockStmt"


    // $ANTLR start "stmt"
    // LPMEDSemAnalyzer.g:47:1: stmt options {backtrack=true; } : ( assign | ifStmt | ^( CWHILE expr blockStmt ) | ^( CFOR assign expr assign blockStmt ) | deviceFuncID | blockStmt | ^( CBREAKPOINT INT ) | ^( CREGMETHACCESS ID expr ) | CTERMINATEALL | functionCall );
    public void stmt() // throws RecognitionException [1]
    {   
        try 
    	{
            // LPMEDSemAnalyzer.g:49:1: ( assign | ifStmt | ^( CWHILE expr blockStmt ) | ^( CFOR assign expr assign blockStmt ) | deviceFuncID | blockStmt | ^( CBREAKPOINT INT ) | ^( CREGMETHACCESS ID expr ) | CTERMINATEALL | functionCall )
            int alt5 = 10;
            switch ( input.LA(1) ) 
            {
            case CASSIGN:
            	{
                alt5 = 1;
                }
                break;
            case CIFTE:
            	{
                alt5 = 2;
                }
                break;
            case CWHILE:
            	{
                alt5 = 3;
                }
                break;
            case CFOR:
            	{
                alt5 = 4;
                }
                break;
            case CCALL:
            	{
                alt5 = 5;
                }
                break;
            case CSTATEMENT:
            	{
                alt5 = 6;
                }
                break;
            case CBREAKPOINT:
            	{
                alt5 = 7;
                }
                break;
            case CREGMETHACCESS:
            	{
                alt5 = 8;
                }
                break;
            case CTERMINATEALL:
            	{
                alt5 = 9;
                }
                break;
            case CASYNCFUNCCALL:
            case CSYNCFUNCCALL:
            case CWAITFUNCFINISH:
            	{
                alt5 = 10;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
            	    NoViableAltException nvae_d5s0 =
            	        new NoViableAltException("", 5, 0, input);

            	    throw nvae_d5s0;
            }

            switch (alt5) 
            {
                case 1 :
                    // LPMEDSemAnalyzer.g:49:5: assign
                    {
                    	PushFollow(FOLLOW_assign_in_stmt173);
                    	assign();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // LPMEDSemAnalyzer.g:50:5: ifStmt
                    {
                    	PushFollow(FOLLOW_ifStmt_in_stmt180);
                    	ifStmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // LPMEDSemAnalyzer.g:51:5: ^( CWHILE expr blockStmt )
                    {
                    	Match(input,CWHILE,FOLLOW_CWHILE_in_stmt187); if (state.failed) return ;

                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.ActiveName = "bool";
                    	}

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_stmt191);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;
                    	PushFollow(FOLLOW_blockStmt_in_stmt193);
                    	blockStmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // LPMEDSemAnalyzer.g:52:5: ^( CFOR assign expr assign blockStmt )
                    {
                    	Match(input,CFOR,FOLLOW_CFOR_in_stmt201); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	PushFollow(FOLLOW_assign_in_stmt203);
                    	assign();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_stmt205);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;
                    	PushFollow(FOLLOW_assign_in_stmt207);
                    	assign();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;
                    	PushFollow(FOLLOW_blockStmt_in_stmt209);
                    	blockStmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 5 :
                    // LPMEDSemAnalyzer.g:53:5: deviceFuncID
                    {
                    	PushFollow(FOLLOW_deviceFuncID_in_stmt216);
                    	deviceFuncID();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    }
                    break;
                case 6 :
                    // LPMEDSemAnalyzer.g:54:5: blockStmt
                    {
                    	PushFollow(FOLLOW_blockStmt_in_stmt222);
                    	blockStmt();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    }
                    break;
                case 7 :
                    // LPMEDSemAnalyzer.g:55:5: ^( CBREAKPOINT INT )
                    {
                    	Match(input,CBREAKPOINT,FOLLOW_CBREAKPOINT_in_stmt229); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,INT,FOLLOW_INT_in_stmt231); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 8 :
                    // LPMEDSemAnalyzer.g:56:5: ^( CREGMETHACCESS ID expr )
                    {
                    	Match(input,CREGMETHACCESS,FOLLOW_CREGMETHACCESS_in_stmt239); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,ID,FOLLOW_ID_in_stmt241); if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_stmt243);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 9 :
                    // LPMEDSemAnalyzer.g:57:5: CTERMINATEALL
                    {
                    	Match(input,CTERMINATEALL,FOLLOW_CTERMINATEALL_in_stmt250); if (state.failed) return ;

                    }
                    break;
                case 10 :
                    // LPMEDSemAnalyzer.g:58:5: functionCall
                    {
                    	PushFollow(FOLLOW_functionCall_in_stmt256);
                    	functionCall();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "stmt"


    // $ANTLR start "assign"
    // LPMEDSemAnalyzer.g:62:1: assign options {backtrack=true; } : ^( CASSIGN i= ID expr ) ;
    public void assign() // throws RecognitionException [1]
    {   
        CommonTree i = null;

        try 
    	{
            // LPMEDSemAnalyzer.g:63:2: ( ^( CASSIGN i= ID expr ) )
            // LPMEDSemAnalyzer.g:64:4: ^( CASSIGN i= ID expr )
            {
            	Match(input,CASSIGN,FOLLOW_CASSIGN_in_assign280); if (state.failed) return ;

            	Match(input, Token.DOWN, null); if (state.failed) return ;
            	i=(CommonTree)Match(input,ID,FOLLOW_ID_in_assign286); if (state.failed) return ;
            	if ( state.backtracking == 0 ) 
            	{
            	  check.SetActiveVar(i);
            	}
            	PushFollow(FOLLOW_expr_in_assign290);
            	expr();
            	state.followingStackPointer--;
            	if (state.failed) return ;

            	Match(input, Token.UP, null); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "assign"


    // $ANTLR start "ifStmt"
    // LPMEDSemAnalyzer.g:67:1: ifStmt options {backtrack=true; } : ^( CIFTE expr a= blockStmt (b= blockStmt )? ) ;
    public void ifStmt() // throws RecognitionException [1]
    {   
        try 
    	{
            // LPMEDSemAnalyzer.g:69:1: ( ^( CIFTE expr a= blockStmt (b= blockStmt )? ) )
            // LPMEDSemAnalyzer.g:70:3: ^( CIFTE expr a= blockStmt (b= blockStmt )? )
            {
            	if ( state.backtracking == 0 ) 
            	{
            	  check.ActiveName = "bool";
            	}
            	Match(input,CIFTE,FOLLOW_CIFTE_in_ifStmt315); if (state.failed) return ;

            	Match(input, Token.DOWN, null); if (state.failed) return ;
            	PushFollow(FOLLOW_expr_in_ifStmt317);
            	expr();
            	state.followingStackPointer--;
            	if (state.failed) return ;
            	PushFollow(FOLLOW_blockStmt_in_ifStmt321);
            	blockStmt();
            	state.followingStackPointer--;
            	if (state.failed) return ;
            	// LPMEDSemAnalyzer.g:70:58: (b= blockStmt )?
            	int alt6 = 2;
            	int LA6_0 = input.LA(1);

            	if ( (LA6_0 == CSTATEMENT) )
            	{
            	    alt6 = 1;
            	}
            	switch (alt6) 
            	{
            	    case 1 :
            	        // LPMEDSemAnalyzer.g:70:58: b= blockStmt
            	        {
            	        	PushFollow(FOLLOW_blockStmt_in_ifStmt325);
            	        	blockStmt();
            	        	state.followingStackPointer--;
            	        	if (state.failed) return ;

            	        }
            	        break;

            	}


            	Match(input, Token.UP, null); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "ifStmt"


    // $ANTLR start "expr"
    // LPMEDSemAnalyzer.g:73:1: expr options {backtrack=true; } : ( ^( OpOr expr expr ) | ^( OpAnd expr expr ) | ^( OpLogicalB expr expr ) | ^( OpLogicalA expr expr ) | ^( OpAddSub expr expr ) | ^( OpDivMul expr expr ) | ^( OpNegation expr ) | ^( OpUnar expr ) | '(' expr ')' | atom );
    public void expr() // throws RecognitionException [1]
    {   
        try 
    	{
            // LPMEDSemAnalyzer.g:74:1: ( ^( OpOr expr expr ) | ^( OpAnd expr expr ) | ^( OpLogicalB expr expr ) | ^( OpLogicalA expr expr ) | ^( OpAddSub expr expr ) | ^( OpDivMul expr expr ) | ^( OpNegation expr ) | ^( OpUnar expr ) | '(' expr ')' | atom )
            int alt7 = 10;
            switch ( input.LA(1) ) 
            {
            case OpOr:
            	{
                alt7 = 1;
                }
                break;
            case OpAnd:
            	{
                alt7 = 2;
                }
                break;
            case OpLogicalB:
            	{
                alt7 = 3;
                }
                break;
            case OpLogicalA:
            	{
                alt7 = 4;
                }
                break;
            case OpAddSub:
            	{
                alt7 = 5;
                }
                break;
            case OpDivMul:
            	{
                alt7 = 6;
                }
                break;
            case OpNegation:
            	{
                alt7 = 7;
                }
                break;
            case OpUnar:
            	{
                alt7 = 8;
                }
                break;
            case 80:
            	{
                alt7 = 9;
                }
                break;
            case CINT:
            case CFLOAT:
            case CBOOL:
            case OBJECTNAME:
            case CGETSTATE:
            case CREGFUNCACCESS:
            case ID:
            	{
                alt7 = 10;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
            	    NoViableAltException nvae_d7s0 =
            	        new NoViableAltException("", 7, 0, input);

            	    throw nvae_d7s0;
            }

            switch (alt7) 
            {
                case 1 :
                    // LPMEDSemAnalyzer.g:75:1: ^( OpOr expr expr )
                    {
                    	Match(input,OpOr,FOLLOW_OpOr_in_expr345); if (state.failed) return ;

                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = true;
                    	}

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_expr349);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = false;
                    	}
                    	PushFollow(FOLLOW_expr_in_expr353);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // LPMEDSemAnalyzer.g:76:2: ^( OpAnd expr expr )
                    {
                    	Match(input,OpAnd,FOLLOW_OpAnd_in_expr359); if (state.failed) return ;

                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = true;
                    	}

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_expr363);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = false;
                    	}
                    	PushFollow(FOLLOW_expr_in_expr367);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // LPMEDSemAnalyzer.g:77:2: ^( OpLogicalB expr expr )
                    {
                    	Match(input,OpLogicalB,FOLLOW_OpLogicalB_in_expr373); if (state.failed) return ;

                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = true;
                    	}

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_expr377);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = false;
                    	}
                    	PushFollow(FOLLOW_expr_in_expr381);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 4 :
                    // LPMEDSemAnalyzer.g:78:2: ^( OpLogicalA expr expr )
                    {
                    	Match(input,OpLogicalA,FOLLOW_OpLogicalA_in_expr387); if (state.failed) return ;

                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = true;
                    	}

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_expr391);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = false;
                    	}
                    	PushFollow(FOLLOW_expr_in_expr395);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 5 :
                    // LPMEDSemAnalyzer.g:79:2: ^( OpAddSub expr expr )
                    {
                    	Match(input,OpAddSub,FOLLOW_OpAddSub_in_expr401); if (state.failed) return ;

                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = true;
                    	}

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_expr405);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = false;
                    	}
                    	PushFollow(FOLLOW_expr_in_expr409);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 6 :
                    // LPMEDSemAnalyzer.g:80:2: ^( OpDivMul expr expr )
                    {
                    	Match(input,OpDivMul,FOLLOW_OpDivMul_in_expr415); if (state.failed) return ;

                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = true;
                    	}

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_expr419);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.IsExpr = false;
                    	}
                    	PushFollow(FOLLOW_expr_in_expr423);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 7 :
                    // LPMEDSemAnalyzer.g:81:2: ^( OpNegation expr )
                    {
                    	Match(input,OpNegation,FOLLOW_OpNegation_in_expr429); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_expr431);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 8 :
                    // LPMEDSemAnalyzer.g:82:2: ^( OpUnar expr )
                    {
                    	Match(input,OpUnar,FOLLOW_OpUnar_in_expr437); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_expr439);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 9 :
                    // LPMEDSemAnalyzer.g:83:2: '(' expr ')'
                    {
                    	Match(input,80,FOLLOW_80_in_expr444); if (state.failed) return ;
                    	PushFollow(FOLLOW_expr_in_expr446);
                    	expr();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;
                    	Match(input,81,FOLLOW_81_in_expr448); if (state.failed) return ;

                    }
                    break;
                case 10 :
                    // LPMEDSemAnalyzer.g:84:2: atom
                    {
                    	PushFollow(FOLLOW_atom_in_expr451);
                    	atom();
                    	state.followingStackPointer--;
                    	if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "expr"


    // $ANTLR start "atom"
    // LPMEDSemAnalyzer.g:87:1: atom options {backtrack=true; } : ( ID | ^(v= CFLOAT FLOAT ) | ^(v= CINT INT ) | ^(v= CBOOL DBOOL ) | ^( CREGFUNCACCESS ID ) | ^(v= OBJECTNAME main= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME name= ID ) | ^(v= CGETSTATE ^( OBJECTNAME name= ID ) ^( NODES (nodes+= ID )* ) ) );
    public void atom() // throws RecognitionException [1]
    {   
        CommonTree v = null;
        CommonTree main = null;
        CommonTree name = null;
        CommonTree ID2 = null;
        CommonTree nodes = null;
        IList list_nodes = null;

        try 
    	{
            // LPMEDSemAnalyzer.g:92:2: ( ID | ^(v= CFLOAT FLOAT ) | ^(v= CINT INT ) | ^(v= CBOOL DBOOL ) | ^( CREGFUNCACCESS ID ) | ^(v= OBJECTNAME main= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME name= ID ) | ^(v= CGETSTATE ^( OBJECTNAME name= ID ) ^( NODES (nodes+= ID )* ) ) )
            int alt10 = 7;
            switch ( input.LA(1) ) 
            {
            case ID:
            	{
                alt10 = 1;
                }
                break;
            case CFLOAT:
            	{
                alt10 = 2;
                }
                break;
            case CINT:
            	{
                alt10 = 3;
                }
                break;
            case CBOOL:
            	{
                alt10 = 4;
                }
                break;
            case CREGFUNCACCESS:
            	{
                alt10 = 5;
                }
                break;
            case OBJECTNAME:
            	{
                alt10 = 6;
                }
                break;
            case CGETSTATE:
            	{
                alt10 = 7;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
            	    NoViableAltException nvae_d10s0 =
            	        new NoViableAltException("", 10, 0, input);

            	    throw nvae_d10s0;
            }

            switch (alt10) 
            {
                case 1 :
                    // LPMEDSemAnalyzer.g:93:4: ID
                    {
                    	ID2=(CommonTree)Match(input,ID,FOLLOW_ID_in_atom475); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  if (check.IsExpr) check.SetActiveVar(ID2); else check.CheckVarType(ID2);
                    	}

                    }
                    break;
                case 2 :
                    // LPMEDSemAnalyzer.g:95:4: ^(v= CFLOAT FLOAT )
                    {
                    	v=(CommonTree)Match(input,CFLOAT,FOLLOW_CFLOAT_in_atom491); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,FLOAT,FOLLOW_FLOAT_in_atom493); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  if (check.IsExpr) check.ActiveName = "float"; else check.CheckType("float", v.Line, v.CharPositionInLine);
                    	}

                    }
                    break;
                case 3 :
                    // LPMEDSemAnalyzer.g:97:5: ^(v= CINT INT )
                    {
                    	v=(CommonTree)Match(input,CINT,FOLLOW_CINT_in_atom509); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,INT,FOLLOW_INT_in_atom511); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  if (check.IsExpr) check.ActiveName = "int"; else check.CheckType("int", v.Line, v.CharPositionInLine);
                    	}

                    }
                    break;
                case 4 :
                    // LPMEDSemAnalyzer.g:99:4: ^(v= CBOOL DBOOL )
                    {
                    	v=(CommonTree)Match(input,CBOOL,FOLLOW_CBOOL_in_atom526); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,DBOOL,FOLLOW_DBOOL_in_atom528); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  if (check.IsExpr) check.ActiveName = "bool"; else check.CheckType("bool", v.Line, v.CharPositionInLine);
                    	}

                    }
                    break;
                case 5 :
                    // LPMEDSemAnalyzer.g:101:4: ^( CREGFUNCACCESS ID )
                    {
                    	Match(input,CREGFUNCACCESS,FOLLOW_CREGFUNCACCESS_in_atom539); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,ID,FOLLOW_ID_in_atom541); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 6 :
                    // LPMEDSemAnalyzer.g:103:4: ^(v= OBJECTNAME main= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME name= ID )
                    {
                    	v=(CommonTree)Match(input,OBJECTNAME,FOLLOW_OBJECTNAME_in_atom554); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	main=(CommonTree)Match(input,ID,FOLLOW_ID_in_atom560); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	Match(input,NODES,FOLLOW_NODES_in_atom564); if (state.failed) return ;

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); if (state.failed) return ;
                    	    // LPMEDSemAnalyzer.g:103:46: (nodes+= ID )*
                    	    do 
                    	    {
                    	        int alt8 = 2;
                    	        int LA8_0 = input.LA(1);

                    	        if ( (LA8_0 == ID) )
                    	        {
                    	            alt8 = 1;
                    	        }


                    	        switch (alt8) 
                    	    	{
                    	    		case 1 :
                    	    		    // LPMEDSemAnalyzer.g:103:46: nodes+= ID
                    	    		    {
                    	    		    	nodes=(CommonTree)Match(input,ID,FOLLOW_ID_in_atom570); if (state.failed) return ;
                    	    		    	if (list_nodes == null) list_nodes = new ArrayList();
                    	    		    	list_nodes.Add(nodes);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop8;
                    	        }
                    	    } while (true);

                    	    loop8:
                    	    	;	// Stops C# compiler whining that label 'loop8' has no statements


                    	    Match(input, Token.UP, null); if (state.failed) return ;
                    	}
                    	Match(input,MEMBERNAME,FOLLOW_MEMBERNAME_in_atom575); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	name=(CommonTree)Match(input,ID,FOLLOW_ID_in_atom581); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  if (check.IsExpr) check.ActiveName = "int"; else check.CheckType("int", v.Line, v.CharPositionInLine);
                    	  				check.CheckNamedStateID(main, list_nodes, name);
                    	}

                    }
                    break;
                case 7 :
                    // LPMEDSemAnalyzer.g:107:4: ^(v= CGETSTATE ^( OBJECTNAME name= ID ) ^( NODES (nodes+= ID )* ) )
                    {
                    	v=(CommonTree)Match(input,CGETSTATE,FOLLOW_CGETSTATE_in_atom605); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,OBJECTNAME,FOLLOW_OBJECTNAME_in_atom608); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	name=(CommonTree)Match(input,ID,FOLLOW_ID_in_atom612); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	Match(input,NODES,FOLLOW_NODES_in_atom616); if (state.failed) return ;

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); if (state.failed) return ;
                    	    // LPMEDSemAnalyzer.g:107:55: (nodes+= ID )*
                    	    do 
                    	    {
                    	        int alt9 = 2;
                    	        int LA9_0 = input.LA(1);

                    	        if ( (LA9_0 == ID) )
                    	        {
                    	            alt9 = 1;
                    	        }


                    	        switch (alt9) 
                    	    	{
                    	    		case 1 :
                    	    		    // LPMEDSemAnalyzer.g:107:55: nodes+= ID
                    	    		    {
                    	    		    	nodes=(CommonTree)Match(input,ID,FOLLOW_ID_in_atom620); if (state.failed) return ;
                    	    		    	if (list_nodes == null) list_nodes = new ArrayList();
                    	    		    	list_nodes.Add(nodes);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop9;
                    	        }
                    	    } while (true);

                    	    loop9:
                    	    	;	// Stops C# compiler whining that label 'loop9' has no statements


                    	    Match(input, Token.UP, null); if (state.failed) return ;
                    	}

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  if (check.IsExpr) check.ActiveName = "int"; else check.CheckType("int", v.Line, v.CharPositionInLine);
                    	  				check.GetNodeByFullPath(name, name.Text, list_nodes);
                    	}

                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "atom"

    protected class deviceFuncID_scope 
    {
        protected internal //virtual pins of method (or list of pins of several methods)
         List<int> pouts;
        protected internal List<int> pins;
    }
    protected Stack deviceFuncID_stack = new Stack();


    // $ANTLR start "deviceFuncID"
    // LPMEDSemAnalyzer.g:112:1: deviceFuncID : ( ^( CCALL ^(ct= CSYNCCALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) ) | ^( CCALL ^(ct= CASYNCCALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) ) | ^( CCALL ^(ct= CENDTHECALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) ) | ^( CCALL ^(ct= CWAITTHECALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) ) | ^( CCALL ^(ct= CWAITANYCALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME node= ID ) ) ) );
    public void deviceFuncID() // throws RecognitionException [1]
    {   
        deviceFuncID_stack.Push(new deviceFuncID_scope());
        CommonTree ct = null;
        CommonTree dn = null;
        CommonTree mn = null;
        CommonTree node = null;
        CommonTree nodes = null;
        IList list_nodes = null;

        try 
    	{
            // LPMEDSemAnalyzer.g:118:1: ( ^( CCALL ^(ct= CSYNCCALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) ) | ^( CCALL ^(ct= CASYNCCALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) ) | ^( CCALL ^(ct= CENDTHECALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) ) | ^( CCALL ^(ct= CWAITTHECALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) ) | ^( CCALL ^(ct= CWAITANYCALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME node= ID ) ) ) )
            int alt16 = 5;
            int LA16_0 = input.LA(1);

            if ( (LA16_0 == CCALL) )
            {
                int LA16_1 = input.LA(2);

                if ( (LA16_1 == DOWN) )
                {
                    switch ( input.LA(3) ) 
                    {
                    case CSYNCCALL:
                    	{
                        alt16 = 1;
                        }
                        break;
                    case CASYNCCALL:
                    	{
                        alt16 = 2;
                        }
                        break;
                    case CENDTHECALL:
                    	{
                        alt16 = 3;
                        }
                        break;
                    case CWAITTHECALL:
                    	{
                        alt16 = 4;
                        }
                        break;
                    case CWAITANYCALL:
                    	{
                        alt16 = 5;
                        }
                        break;
                    	default:
                    	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
                    	    NoViableAltException nvae_d16s2 =
                    	        new NoViableAltException("", 16, 2, input);

                    	    throw nvae_d16s2;
                    }

                }
                else 
                {
                    if ( state.backtracking > 0 ) {state.failed = true; return ;}
                    NoViableAltException nvae_d16s1 =
                        new NoViableAltException("", 16, 1, input);

                    throw nvae_d16s1;
                }
            }
            else 
            {
                if ( state.backtracking > 0 ) {state.failed = true; return ;}
                NoViableAltException nvae_d16s0 =
                    new NoViableAltException("", 16, 0, input);

                throw nvae_d16s0;
            }
            switch (alt16) 
            {
                case 1 :
                    // LPMEDSemAnalyzer.g:118:5: ^( CCALL ^(ct= CSYNCCALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) )
                    {
                    	Match(input,CCALL,FOLLOW_CCALL_in_deviceFuncID645); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	ct=(CommonTree)Match(input,CSYNCCALL,FOLLOW_CSYNCCALL_in_deviceFuncID650); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,OBJECTNAME,FOLLOW_OBJECTNAME_in_deviceFuncID653); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	dn=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID657); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	Match(input,NODES,FOLLOW_NODES_in_deviceFuncID661); if (state.failed) return ;

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); if (state.failed) return ;
                    	    // LPMEDSemAnalyzer.g:118:61: (nodes+= ID )*
                    	    do 
                    	    {
                    	        int alt11 = 2;
                    	        int LA11_0 = input.LA(1);

                    	        if ( (LA11_0 == ID) )
                    	        {
                    	            alt11 = 1;
                    	        }


                    	        switch (alt11) 
                    	    	{
                    	    		case 1 :
                    	    		    // LPMEDSemAnalyzer.g:118:61: nodes+= ID
                    	    		    {
                    	    		    	nodes=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID665); if (state.failed) return ;
                    	    		    	if (list_nodes == null) list_nodes = new ArrayList();
                    	    		    	list_nodes.Add(nodes);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop11;
                    	        }
                    	    } while (true);

                    	    loop11:
                    	    	;	// Stops C# compiler whining that label 'loop11' has no statements


                    	    Match(input, Token.UP, null); if (state.failed) return ;
                    	}
                    	Match(input,MEMBERNAME,FOLLOW_MEMBERNAME_in_deviceFuncID670); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	mn=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID674); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.CheckMethodID(ct, ((dn != null) ? dn.Text : null), list_nodes, mn);
                    	}

                    }
                    break;
                case 2 :
                    // LPMEDSemAnalyzer.g:121:5: ^( CCALL ^(ct= CASYNCCALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) )
                    {
                    	Match(input,CCALL,FOLLOW_CCALL_in_deviceFuncID690); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	ct=(CommonTree)Match(input,CASYNCCALL,FOLLOW_CASYNCCALL_in_deviceFuncID695); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,OBJECTNAME,FOLLOW_OBJECTNAME_in_deviceFuncID698); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	dn=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID702); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	Match(input,NODES,FOLLOW_NODES_in_deviceFuncID706); if (state.failed) return ;

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); if (state.failed) return ;
                    	    // LPMEDSemAnalyzer.g:121:62: (nodes+= ID )*
                    	    do 
                    	    {
                    	        int alt12 = 2;
                    	        int LA12_0 = input.LA(1);

                    	        if ( (LA12_0 == ID) )
                    	        {
                    	            alt12 = 1;
                    	        }


                    	        switch (alt12) 
                    	    	{
                    	    		case 1 :
                    	    		    // LPMEDSemAnalyzer.g:121:62: nodes+= ID
                    	    		    {
                    	    		    	nodes=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID710); if (state.failed) return ;
                    	    		    	if (list_nodes == null) list_nodes = new ArrayList();
                    	    		    	list_nodes.Add(nodes);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop12;
                    	        }
                    	    } while (true);

                    	    loop12:
                    	    	;	// Stops C# compiler whining that label 'loop12' has no statements


                    	    Match(input, Token.UP, null); if (state.failed) return ;
                    	}
                    	Match(input,MEMBERNAME,FOLLOW_MEMBERNAME_in_deviceFuncID715); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	mn=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID719); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.CheckMethodID(ct, ((dn != null) ? dn.Text : null), list_nodes, mn);
                    	}

                    }
                    break;
                case 3 :
                    // LPMEDSemAnalyzer.g:124:5: ^( CCALL ^(ct= CENDTHECALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) )
                    {
                    	Match(input,CCALL,FOLLOW_CCALL_in_deviceFuncID737); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	ct=(CommonTree)Match(input,CENDTHECALL,FOLLOW_CENDTHECALL_in_deviceFuncID742); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,OBJECTNAME,FOLLOW_OBJECTNAME_in_deviceFuncID745); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	dn=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID749); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	Match(input,NODES,FOLLOW_NODES_in_deviceFuncID753); if (state.failed) return ;

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); if (state.failed) return ;
                    	    // LPMEDSemAnalyzer.g:124:63: (nodes+= ID )*
                    	    do 
                    	    {
                    	        int alt13 = 2;
                    	        int LA13_0 = input.LA(1);

                    	        if ( (LA13_0 == ID) )
                    	        {
                    	            alt13 = 1;
                    	        }


                    	        switch (alt13) 
                    	    	{
                    	    		case 1 :
                    	    		    // LPMEDSemAnalyzer.g:124:63: nodes+= ID
                    	    		    {
                    	    		    	nodes=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID757); if (state.failed) return ;
                    	    		    	if (list_nodes == null) list_nodes = new ArrayList();
                    	    		    	list_nodes.Add(nodes);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop13;
                    	        }
                    	    } while (true);

                    	    loop13:
                    	    	;	// Stops C# compiler whining that label 'loop13' has no statements


                    	    Match(input, Token.UP, null); if (state.failed) return ;
                    	}
                    	Match(input,MEMBERNAME,FOLLOW_MEMBERNAME_in_deviceFuncID762); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	mn=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID766); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.CheckMethodID(ct, ((dn != null) ? dn.Text : null), list_nodes, mn);
                    	}

                    }
                    break;
                case 4 :
                    // LPMEDSemAnalyzer.g:127:5: ^( CCALL ^(ct= CWAITTHECALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME mn= ID ) ) )
                    {
                    	Match(input,CCALL,FOLLOW_CCALL_in_deviceFuncID785); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	ct=(CommonTree)Match(input,CWAITTHECALL,FOLLOW_CWAITTHECALL_in_deviceFuncID790); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,OBJECTNAME,FOLLOW_OBJECTNAME_in_deviceFuncID793); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	dn=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID797); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	Match(input,NODES,FOLLOW_NODES_in_deviceFuncID801); if (state.failed) return ;

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); if (state.failed) return ;
                    	    // LPMEDSemAnalyzer.g:127:64: (nodes+= ID )*
                    	    do 
                    	    {
                    	        int alt14 = 2;
                    	        int LA14_0 = input.LA(1);

                    	        if ( (LA14_0 == ID) )
                    	        {
                    	            alt14 = 1;
                    	        }


                    	        switch (alt14) 
                    	    	{
                    	    		case 1 :
                    	    		    // LPMEDSemAnalyzer.g:127:64: nodes+= ID
                    	    		    {
                    	    		    	nodes=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID805); if (state.failed) return ;
                    	    		    	if (list_nodes == null) list_nodes = new ArrayList();
                    	    		    	list_nodes.Add(nodes);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop14;
                    	        }
                    	    } while (true);

                    	    loop14:
                    	    	;	// Stops C# compiler whining that label 'loop14' has no statements


                    	    Match(input, Token.UP, null); if (state.failed) return ;
                    	}
                    	Match(input,MEMBERNAME,FOLLOW_MEMBERNAME_in_deviceFuncID810); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	mn=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID814); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.CheckMethodID(ct, ((dn != null) ? dn.Text : null), list_nodes, mn);
                    	}

                    }
                    break;
                case 5 :
                    // LPMEDSemAnalyzer.g:130:5: ^( CCALL ^(ct= CWAITANYCALL ^( OBJECTNAME dn= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME node= ID ) ) )
                    {
                    	Match(input,CCALL,FOLLOW_CCALL_in_deviceFuncID830); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	ct=(CommonTree)Match(input,CWAITANYCALL,FOLLOW_CWAITANYCALL_in_deviceFuncID835); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	Match(input,OBJECTNAME,FOLLOW_OBJECTNAME_in_deviceFuncID838); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	dn=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID842); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	Match(input,NODES,FOLLOW_NODES_in_deviceFuncID846); if (state.failed) return ;

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); if (state.failed) return ;
                    	    // LPMEDSemAnalyzer.g:130:64: (nodes+= ID )*
                    	    do 
                    	    {
                    	        int alt15 = 2;
                    	        int LA15_0 = input.LA(1);

                    	        if ( (LA15_0 == ID) )
                    	        {
                    	            alt15 = 1;
                    	        }


                    	        switch (alt15) 
                    	    	{
                    	    		case 1 :
                    	    		    // LPMEDSemAnalyzer.g:130:64: nodes+= ID
                    	    		    {
                    	    		    	nodes=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID850); if (state.failed) return ;
                    	    		    	if (list_nodes == null) list_nodes = new ArrayList();
                    	    		    	list_nodes.Add(nodes);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop15;
                    	        }
                    	    } while (true);

                    	    loop15:
                    	    	;	// Stops C# compiler whining that label 'loop15' has no statements


                    	    Match(input, Token.UP, null); if (state.failed) return ;
                    	}
                    	Match(input,MEMBERNAME,FOLLOW_MEMBERNAME_in_deviceFuncID855); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	node=(CommonTree)Match(input,ID,FOLLOW_ID_in_deviceFuncID859); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.CheckMethodID(ct, ((dn != null) ? dn.Text : null), list_nodes, mn);
                    	}

                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
            deviceFuncID_stack.Pop();
        }
        return ;
    }
    // $ANTLR end "deviceFuncID"


    // $ANTLR start "functionCall"
    // LPMEDSemAnalyzer.g:135:1: functionCall : ( ^( CASYNCFUNCCALL ID ( parameter )* ) | ^( CWAITFUNCFINISH ID ( parameter )* ) | ^( CSYNCFUNCCALL ID ( parameter )* ) );
    public void functionCall() // throws RecognitionException [1]
    {   
        CommonTree ID3 = null;
        CommonTree ID4 = null;
        CommonTree ID5 = null;

        try 
    	{
            // LPMEDSemAnalyzer.g:136:1: ( ^( CASYNCFUNCCALL ID ( parameter )* ) | ^( CWAITFUNCFINISH ID ( parameter )* ) | ^( CSYNCFUNCCALL ID ( parameter )* ) )
            int alt20 = 3;
            switch ( input.LA(1) ) 
            {
            case CASYNCFUNCCALL:
            	{
                alt20 = 1;
                }
                break;
            case CWAITFUNCFINISH:
            	{
                alt20 = 2;
                }
                break;
            case CSYNCFUNCCALL:
            	{
                alt20 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
            	    NoViableAltException nvae_d20s0 =
            	        new NoViableAltException("", 20, 0, input);

            	    throw nvae_d20s0;
            }

            switch (alt20) 
            {
                case 1 :
                    // LPMEDSemAnalyzer.g:137:4: ^( CASYNCFUNCCALL ID ( parameter )* )
                    {
                    	Match(input,CASYNCFUNCCALL,FOLLOW_CASYNCFUNCCALL_in_functionCall882); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	ID3=(CommonTree)Match(input,ID,FOLLOW_ID_in_functionCall884); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.NewFunctionCall(ID3);
                    	}
                    	// LPMEDSemAnalyzer.g:137:54: ( parameter )*
                    	do 
                    	{
                    	    int alt17 = 2;
                    	    int LA17_0 = input.LA(1);

                    	    if ( (LA17_0 == PARAM) )
                    	    {
                    	        alt17 = 1;
                    	    }


                    	    switch (alt17) 
                    		{
                    			case 1 :
                    			    // LPMEDSemAnalyzer.g:137:54: parameter
                    			    {
                    			    	PushFollow(FOLLOW_parameter_in_functionCall888);
                    			    	parameter();
                    			    	state.followingStackPointer--;
                    			    	if (state.failed) return ;

                    			    }
                    			    break;

                    			default:
                    			    goto loop17;
                    	    }
                    	} while (true);

                    	loop17:
                    		;	// Stops C# compiler whining that label 'loop17' has no statements

                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.FunctionCallFinish();
                    	}

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 2 :
                    // LPMEDSemAnalyzer.g:138:6: ^( CWAITFUNCFINISH ID ( parameter )* )
                    {
                    	Match(input,CWAITFUNCFINISH,FOLLOW_CWAITFUNCFINISH_in_functionCall900); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	ID4=(CommonTree)Match(input,ID,FOLLOW_ID_in_functionCall902); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.NewFunctionCall(ID4);
                    	}
                    	// LPMEDSemAnalyzer.g:138:57: ( parameter )*
                    	do 
                    	{
                    	    int alt18 = 2;
                    	    int LA18_0 = input.LA(1);

                    	    if ( (LA18_0 == PARAM) )
                    	    {
                    	        alt18 = 1;
                    	    }


                    	    switch (alt18) 
                    		{
                    			case 1 :
                    			    // LPMEDSemAnalyzer.g:138:57: parameter
                    			    {
                    			    	PushFollow(FOLLOW_parameter_in_functionCall906);
                    			    	parameter();
                    			    	state.followingStackPointer--;
                    			    	if (state.failed) return ;

                    			    }
                    			    break;

                    			default:
                    			    goto loop18;
                    	    }
                    	} while (true);

                    	loop18:
                    		;	// Stops C# compiler whining that label 'loop18' has no statements

                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.FunctionCallFinish();
                    	}

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // LPMEDSemAnalyzer.g:139:5: ^( CSYNCFUNCCALL ID ( parameter )* )
                    {
                    	Match(input,CSYNCFUNCCALL,FOLLOW_CSYNCFUNCCALL_in_functionCall917); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	ID5=(CommonTree)Match(input,ID,FOLLOW_ID_in_functionCall919); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.NewFunctionCall(ID5);
                    	}
                    	// LPMEDSemAnalyzer.g:139:54: ( parameter )*
                    	do 
                    	{
                    	    int alt19 = 2;
                    	    int LA19_0 = input.LA(1);

                    	    if ( (LA19_0 == PARAM) )
                    	    {
                    	        alt19 = 1;
                    	    }


                    	    switch (alt19) 
                    		{
                    			case 1 :
                    			    // LPMEDSemAnalyzer.g:139:54: parameter
                    			    {
                    			    	PushFollow(FOLLOW_parameter_in_functionCall923);
                    			    	parameter();
                    			    	state.followingStackPointer--;
                    			    	if (state.failed) return ;

                    			    }
                    			    break;

                    			default:
                    			    goto loop19;
                    	    }
                    	} while (true);

                    	loop19:
                    		;	// Stops C# compiler whining that label 'loop19' has no statements

                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.FunctionCallFinish();
                    	}

                    	Match(input, Token.UP, null); if (state.failed) return ;

                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "functionCall"


    // $ANTLR start "parameter"
    // LPMEDSemAnalyzer.g:143:1: parameter : ^( PARAM parameterValue ) ;
    public void parameter() // throws RecognitionException [1]
    {   
        try 
    	{
            // LPMEDSemAnalyzer.g:143:11: ( ^( PARAM parameterValue ) )
            // LPMEDSemAnalyzer.g:144:2: ^( PARAM parameterValue )
            {
            	Match(input,PARAM,FOLLOW_PARAM_in_parameter940); if (state.failed) return ;

            	if ( state.backtracking == 0 ) 
            	{
            	  check.FactParameterWritten();
            	}

            	Match(input, Token.DOWN, null); if (state.failed) return ;
            	PushFollow(FOLLOW_parameterValue_in_parameter944);
            	parameterValue();
            	state.followingStackPointer--;
            	if (state.failed) return ;

            	Match(input, Token.UP, null); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "parameter"


    // $ANTLR start "parameterValue"
    // LPMEDSemAnalyzer.g:147:1: parameterValue : ( ID | INT | ^( OBJECTNAME name= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME sname= ID ) );
    public void parameterValue() // throws RecognitionException [1]
    {   
        CommonTree name = null;
        CommonTree sname = null;
        CommonTree ID6 = null;
        CommonTree nodes = null;
        IList list_nodes = null;

        try 
    	{
            // LPMEDSemAnalyzer.g:147:16: ( ID | INT | ^( OBJECTNAME name= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME sname= ID ) )
            int alt22 = 3;
            switch ( input.LA(1) ) 
            {
            case ID:
            	{
                alt22 = 1;
                }
                break;
            case INT:
            	{
                alt22 = 2;
                }
                break;
            case OBJECTNAME:
            	{
                alt22 = 3;
                }
                break;
            	default:
            	    if ( state.backtracking > 0 ) {state.failed = true; return ;}
            	    NoViableAltException nvae_d22s0 =
            	        new NoViableAltException("", 22, 0, input);

            	    throw nvae_d22s0;
            }

            switch (alt22) 
            {
                case 1 :
                    // LPMEDSemAnalyzer.g:148:4: ID
                    {
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.ActiveName = "int";
                    	}
                    	ID6=(CommonTree)Match(input,ID,FOLLOW_ID_in_parameterValue959); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.CheckVarType(ID6);
                    	}

                    }
                    break;
                case 2 :
                    // LPMEDSemAnalyzer.g:149:6: INT
                    {
                    	Match(input,INT,FOLLOW_INT_in_parameterValue970); if (state.failed) return ;

                    }
                    break;
                case 3 :
                    // LPMEDSemAnalyzer.g:150:5: ^( OBJECTNAME name= ID ) ^( NODES (nodes+= ID )* ) ^( MEMBERNAME sname= ID )
                    {
                    	Match(input,OBJECTNAME,FOLLOW_OBJECTNAME_in_parameterValue986); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	name=(CommonTree)Match(input,ID,FOLLOW_ID_in_parameterValue990); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	Match(input,NODES,FOLLOW_NODES_in_parameterValue994); if (state.failed) return ;

                    	if ( input.LA(1) == Token.DOWN )
                    	{
                    	    Match(input, Token.DOWN, null); if (state.failed) return ;
                    	    // LPMEDSemAnalyzer.g:150:40: (nodes+= ID )*
                    	    do 
                    	    {
                    	        int alt21 = 2;
                    	        int LA21_0 = input.LA(1);

                    	        if ( (LA21_0 == ID) )
                    	        {
                    	            alt21 = 1;
                    	        }


                    	        switch (alt21) 
                    	    	{
                    	    		case 1 :
                    	    		    // LPMEDSemAnalyzer.g:150:40: nodes+= ID
                    	    		    {
                    	    		    	nodes=(CommonTree)Match(input,ID,FOLLOW_ID_in_parameterValue998); if (state.failed) return ;
                    	    		    	if (list_nodes == null) list_nodes = new ArrayList();
                    	    		    	list_nodes.Add(nodes);


                    	    		    }
                    	    		    break;

                    	    		default:
                    	    		    goto loop21;
                    	        }
                    	    } while (true);

                    	    loop21:
                    	    	;	// Stops C# compiler whining that label 'loop21' has no statements


                    	    Match(input, Token.UP, null); if (state.failed) return ;
                    	}
                    	Match(input,MEMBERNAME,FOLLOW_MEMBERNAME_in_parameterValue1003); if (state.failed) return ;

                    	Match(input, Token.DOWN, null); if (state.failed) return ;
                    	sname=(CommonTree)Match(input,ID,FOLLOW_ID_in_parameterValue1007); if (state.failed) return ;

                    	Match(input, Token.UP, null); if (state.failed) return ;
                    	if ( state.backtracking == 0 ) 
                    	{
                    	  check.CheckNamedStateID(name, list_nodes, sname);
                    	}

                    }
                    break;

            }
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "parameterValue"


    // $ANTLR start "dMID"
    // LPMEDSemAnalyzer.g:154:1: dMID : ID ;
    public void dMID() // throws RecognitionException [1]
    {   
        CommonTree ID7 = null;

        try 
    	{
            // LPMEDSemAnalyzer.g:154:7: ( ID )
            // LPMEDSemAnalyzer.g:154:9: ID
            {
            	ID7=(CommonTree)Match(input,ID,FOLLOW_ID_in_dMID1024); if (state.failed) return ;
            	if ( state.backtracking == 0 ) 
            	{
            	  check.SetActiveVar(ID7);
            	}

            }

        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
        }
        finally 
    	{
        }
        return ;
    }
    // $ANTLR end "dMID"

    // Delegated rules


	private void InitializeCyclicDFAs()
	{
	}

 

    public static readonly BitSet FOLLOW_CPROGRAM_in_program67 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_CDEVICE_in_program70 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_program74 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_block_in_program79 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_varDecList_in_block92 = new BitSet(new ulong[]{0x0000000000000140UL});
    public static readonly BitSet FOLLOW_blockStmt_in_block96 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_varDecListAtom_in_varDecList106 = new BitSet(new ulong[]{0x0000000000000142UL});
    public static readonly BitSet FOLLOW_CTYPE_in_varDecListAtom118 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_TYPE_in_varDecListAtom120 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_peremDecList_in_varDecListAtom124 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_ID_in_peremDecList136 = new BitSet(new ulong[]{0x0000000000000002UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CSTATEMENT_in_blockStmt150 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_stmt_in_blockStmt152 = new BitSet(new ulong[]{0x0000000F60011F08UL});
    public static readonly BitSet FOLLOW_assign_in_stmt173 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ifStmt_in_stmt180 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CWHILE_in_stmt187 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_stmt191 = new BitSet(new ulong[]{0x0000000000000100UL});
    public static readonly BitSet FOLLOW_blockStmt_in_stmt193 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CFOR_in_stmt201 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_assign_in_stmt203 = new BitSet(new ulong[]{0x0001FE00920E0000UL,0x0000000000010040UL});
    public static readonly BitSet FOLLOW_expr_in_stmt205 = new BitSet(new ulong[]{0x0000000000000400UL});
    public static readonly BitSet FOLLOW_assign_in_stmt207 = new BitSet(new ulong[]{0x0000000000000100UL});
    public static readonly BitSet FOLLOW_blockStmt_in_stmt209 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_deviceFuncID_in_stmt216 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_blockStmt_in_stmt222 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CBREAKPOINT_in_stmt229 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_INT_in_stmt231 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CREGMETHACCESS_in_stmt239 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_stmt241 = new BitSet(new ulong[]{0x0001FE00920E0000UL,0x0000000000010040UL});
    public static readonly BitSet FOLLOW_expr_in_stmt243 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CTERMINATEALL_in_stmt250 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_functionCall_in_stmt256 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CASSIGN_in_assign280 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_assign286 = new BitSet(new ulong[]{0x0001FE00920E0000UL,0x0000000000010040UL});
    public static readonly BitSet FOLLOW_expr_in_assign290 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CIFTE_in_ifStmt315 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_ifStmt317 = new BitSet(new ulong[]{0x0000000000000100UL});
    public static readonly BitSet FOLLOW_blockStmt_in_ifStmt321 = new BitSet(new ulong[]{0x0000000000000108UL});
    public static readonly BitSet FOLLOW_blockStmt_in_ifStmt325 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_OpOr_in_expr345 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_expr349 = new BitSet(new ulong[]{0x0001FE00920E0000UL,0x0000000000010040UL});
    public static readonly BitSet FOLLOW_expr_in_expr353 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_OpAnd_in_expr359 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_expr363 = new BitSet(new ulong[]{0x0001FE00920E0000UL,0x0000000000010040UL});
    public static readonly BitSet FOLLOW_expr_in_expr367 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_OpLogicalB_in_expr373 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_expr377 = new BitSet(new ulong[]{0x0001FE00920E0000UL,0x0000000000010040UL});
    public static readonly BitSet FOLLOW_expr_in_expr381 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_OpLogicalA_in_expr387 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_expr391 = new BitSet(new ulong[]{0x0001FE00920E0000UL,0x0000000000010040UL});
    public static readonly BitSet FOLLOW_expr_in_expr395 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_OpAddSub_in_expr401 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_expr405 = new BitSet(new ulong[]{0x0001FE00920E0000UL,0x0000000000010040UL});
    public static readonly BitSet FOLLOW_expr_in_expr409 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_OpDivMul_in_expr415 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_expr419 = new BitSet(new ulong[]{0x0001FE00920E0000UL,0x0000000000010040UL});
    public static readonly BitSet FOLLOW_expr_in_expr423 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_OpNegation_in_expr429 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_expr431 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_OpUnar_in_expr437 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_expr_in_expr439 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_80_in_expr444 = new BitSet(new ulong[]{0x0001FE00920E0000UL,0x0000000000010040UL});
    public static readonly BitSet FOLLOW_expr_in_expr446 = new BitSet(new ulong[]{0x0000000000000000UL,0x0000000000020000UL});
    public static readonly BitSet FOLLOW_81_in_expr448 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_atom_in_expr451 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_ID_in_atom475 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_CFLOAT_in_atom491 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_FLOAT_in_atom493 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CINT_in_atom509 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_INT_in_atom511 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CBOOL_in_atom526 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_DBOOL_in_atom528 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CREGFUNCACCESS_in_atom539 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_atom541 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_OBJECTNAME_in_atom554 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_atom560 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_NODES_in_atom564 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_atom570 = new BitSet(new ulong[]{0x0000000000000008UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_MEMBERNAME_in_atom575 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_atom581 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CGETSTATE_in_atom605 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_OBJECTNAME_in_atom608 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_atom612 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_NODES_in_atom616 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_atom620 = new BitSet(new ulong[]{0x0000000000000008UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_CCALL_in_deviceFuncID645 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_CSYNCCALL_in_deviceFuncID650 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_OBJECTNAME_in_deviceFuncID653 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID657 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_NODES_in_deviceFuncID661 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID665 = new BitSet(new ulong[]{0x0000000000000008UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_MEMBERNAME_in_deviceFuncID670 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID674 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CCALL_in_deviceFuncID690 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_CASYNCCALL_in_deviceFuncID695 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_OBJECTNAME_in_deviceFuncID698 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID702 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_NODES_in_deviceFuncID706 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID710 = new BitSet(new ulong[]{0x0000000000000008UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_MEMBERNAME_in_deviceFuncID715 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID719 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CCALL_in_deviceFuncID737 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_CENDTHECALL_in_deviceFuncID742 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_OBJECTNAME_in_deviceFuncID745 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID749 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_NODES_in_deviceFuncID753 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID757 = new BitSet(new ulong[]{0x0000000000000008UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_MEMBERNAME_in_deviceFuncID762 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID766 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CCALL_in_deviceFuncID785 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_CWAITTHECALL_in_deviceFuncID790 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_OBJECTNAME_in_deviceFuncID793 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID797 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_NODES_in_deviceFuncID801 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID805 = new BitSet(new ulong[]{0x0000000000000008UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_MEMBERNAME_in_deviceFuncID810 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID814 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CCALL_in_deviceFuncID830 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_CWAITANYCALL_in_deviceFuncID835 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_OBJECTNAME_in_deviceFuncID838 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID842 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_NODES_in_deviceFuncID846 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID850 = new BitSet(new ulong[]{0x0000000000000008UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_MEMBERNAME_in_deviceFuncID855 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_deviceFuncID859 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_CASYNCFUNCCALL_in_functionCall882 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_functionCall884 = new BitSet(new ulong[]{0x0000004000000008UL});
    public static readonly BitSet FOLLOW_parameter_in_functionCall888 = new BitSet(new ulong[]{0x0000004000000008UL});
    public static readonly BitSet FOLLOW_CWAITFUNCFINISH_in_functionCall900 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_functionCall902 = new BitSet(new ulong[]{0x0000004000000008UL});
    public static readonly BitSet FOLLOW_parameter_in_functionCall906 = new BitSet(new ulong[]{0x0000004000000008UL});
    public static readonly BitSet FOLLOW_CSYNCFUNCCALL_in_functionCall917 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_functionCall919 = new BitSet(new ulong[]{0x0000004000000008UL});
    public static readonly BitSet FOLLOW_parameter_in_functionCall923 = new BitSet(new ulong[]{0x0000004000000008UL});
    public static readonly BitSet FOLLOW_PARAM_in_parameter940 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_parameterValue_in_parameter944 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_ID_in_parameterValue959 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_INT_in_parameterValue970 = new BitSet(new ulong[]{0x0000000000000002UL});
    public static readonly BitSet FOLLOW_OBJECTNAME_in_parameterValue986 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_parameterValue990 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_NODES_in_parameterValue994 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_parameterValue998 = new BitSet(new ulong[]{0x0000000000000008UL,0x0000000000000040UL});
    public static readonly BitSet FOLLOW_MEMBERNAME_in_parameterValue1003 = new BitSet(new ulong[]{0x0000000000000004UL});
    public static readonly BitSet FOLLOW_ID_in_parameterValue1007 = new BitSet(new ulong[]{0x0000000000000008UL});
    public static readonly BitSet FOLLOW_ID_in_dMID1024 = new BitSet(new ulong[]{0x0000000000000002UL});

}
}